import { getTTSTaskStatus, TTSTaskStatus, type TTSTaskInfo } from '@/api/ai/tts'
import { ttsStorage } from './tts-storage'

/**
 * TTS 任务同步服务 - 统一管理任务状态同步
 */
export class TTSSyncService {
  private static instance: TTSSyncService | null = null
  private syncTimer: number | null = null
  private isSyncing = false
  private readonly SYNC_INTERVAL = 5000 // 5秒同步一次
  private lastSyncTime = 0
  private syncingTaskIds = new Set<number>()
  
  // 任务缓存
  private taskCache = new Map<number, TTSTaskInfo>()
  
  // 事件监听器
  private listeners: {
    taskUpdate: ((taskInfo: TTSTaskInfo) => void)[]
    taskListUpdate: ((tasks: TTSTaskInfo[]) => void)[]
  } = {
    taskUpdate: [],
    taskListUpdate: []
  }

  private constructor() {}

  /**
   * 获取单例实例
   */
  static getInstance(): TTSSyncService {
    if (!TTSSyncService.instance) {
      TTSSyncService.instance = new TTSSyncService()
    }
    return TTSSyncService.instance
  }

  /**
   * 添加事件监听器
   */
  on(event: 'taskUpdate' | 'taskListUpdate', callback: any): void {
    if (this.listeners[event]) {
      this.listeners[event].push(callback)
    }
  }

  /**
   * 移除事件监听器
   */
  off(event: 'taskUpdate' | 'taskListUpdate', callback: any): void {
    if (this.listeners[event]) {
      const index = this.listeners[event].indexOf(callback)
      if (index > -1) {
        this.listeners[event].splice(index, 1)
      }
    }
  }

  /**
   * 触发事件
   */
  private emit(event: 'taskUpdate', taskInfo: TTSTaskInfo): void
  private emit(event: 'taskListUpdate', tasks: TTSTaskInfo[]): void
  private emit(event: string, data: any): void {
    if (event === 'taskUpdate' && this.listeners.taskUpdate) {
      this.listeners.taskUpdate.forEach(callback => callback(data))
    } else if (event === 'taskListUpdate' && this.listeners.taskListUpdate) {
      this.listeners.taskListUpdate.forEach(callback => callback(data))
    }
  }

  /**
   * 开始同步
   */
  async startSync(): Promise<void> {
    if (this.isSyncing) {
      return
    }

    console.log('TTS同步服务：开始同步')
    this.isSyncing = true
    
    // 初始加载所有任务到缓存
    await this.loadTasksToCache()
    
    // 开始定期同步
    this.syncTasks()
  }

  /**
   * 停止同步
   */
  stopSync(): void {
    if (this.syncTimer) {
      clearTimeout(this.syncTimer)
      this.syncTimer = null
    }
    this.isSyncing = false
    this.taskCache.clear()
    console.log('TTS同步服务：停止同步')
  }

  /**
   * 加载任务到缓存
   */
  private async loadTasksToCache(): Promise<void> {
    try {
      const tasks = await ttsStorage.getTTSHistory()
      this.taskCache.clear()
      tasks.forEach(task => {
        this.taskCache.set(task.id, task)
      })
      // 通知任务列表更新（排序后）
      this.emit('taskListUpdate', this.getCachedTasks())
    } catch (error) {
      console.error('加载任务到缓存失败:', error)
    }
  }

  /**
   * 同步任务
   */
  private async syncTasks(): Promise<void> {
    if (!this.isSyncing) {
      return
    }

    // 防止重复执行
    const now = Date.now()
    if (now - this.lastSyncTime < 3000) {
      this.scheduleNextSync()
      return
    }
    this.lastSyncTime = now

    try {
      // 获取所有未完成的任务
      const incompleteTasks = Array.from(this.taskCache.values()).filter(
        task => task.status === TTSTaskStatus.PENDING || task.status === TTSTaskStatus.PROCESSING
      )

      if (incompleteTasks.length === 0) {
        // 没有未完成的任务，延长同步间隔
        this.scheduleNextSync(10000)
        return
      }

      // 过滤掉正在同步的任务
      const tasksToSync = incompleteTasks.filter(task => !this.syncingTaskIds.has(task.id))
      
      if (tasksToSync.length === 0) {
        this.scheduleNextSync()
        return
      }

      console.log(`TTS同步服务：同步 ${tasksToSync.length} 个未完成任务`)

      // 标记正在同步的任务
      tasksToSync.forEach(task => this.syncingTaskIds.add(task.id))

      // 批量同步任务状态
      const syncPromises = tasksToSync.map(task => this.syncTaskStatus(task))
      await Promise.allSettled(syncPromises)

      // 清理同步标记
      tasksToSync.forEach(task => this.syncingTaskIds.delete(task.id))

    } catch (error) {
      console.error('TTS同步服务：同步过程中发生错误:', error)
    }

    // 安排下一次同步
    this.scheduleNextSync()
  }

  /**
   * 同步单个任务状态
   */
  private async syncTaskStatus(task: TTSTaskInfo): Promise<void> {
    try {
      const response = await getTTSTaskStatus(task.id)
      const updatedTask = response.data

      // 检查是否有更新
      const cachedTask = this.taskCache.get(task.id)
      if (cachedTask && this.hasTaskChanged(cachedTask, updatedTask)) {
        // 更新缓存
        this.taskCache.set(task.id, updatedTask)
        
        // 更新数据库
        await ttsStorage.saveTTSTask(updatedTask)
        
        // 触发任务更新事件
        this.emit('taskUpdate', updatedTask)
        
        // 触发列表更新事件（排序后）
        this.emit('taskListUpdate', this.getCachedTasks())
      }

    } catch (error) {
      console.error(`同步任务 ${task.id} 状态时发生错误:`, error)
    }
  }

  /**
   * 检查任务是否有变化
   */
  private hasTaskChanged(oldTask: TTSTaskInfo, newTask: TTSTaskInfo): boolean {
    return oldTask.status !== newTask.status ||
           oldTask.fileUrl !== newTask.fileUrl ||
           oldTask.statusDesc !== newTask.statusDesc ||
           oldTask.errorMessage !== newTask.errorMessage
  }

  /**
   * 安排下一次同步
   */
  private scheduleNextSync(interval?: number): void {
    if (this.isSyncing) {
      if (this.syncTimer) {
        clearTimeout(this.syncTimer)
      }
      
      this.syncTimer = window.setTimeout(() => {
        this.syncTasks()
      }, interval || this.SYNC_INTERVAL)
    }
  }

  /**
   * 添加新任务到缓存
   */
  async addTask(taskInfo: TTSTaskInfo): Promise<void> {
    // 添加到缓存
    this.taskCache.set(taskInfo.id, taskInfo)
    
    // 保存到数据库
    await ttsStorage.saveTTSTask(taskInfo)
    
    // 触发事件
    this.emit('taskUpdate', taskInfo)
    this.emit('taskListUpdate', this.getCachedTasks())
    
    // 立即触发一次同步
    this.lastSyncTime = 0
    if (this.isSyncing) {
      this.syncTasks()
    }
  }

  /**
   * 获取缓存的任务列表（按创建时间倒序）
   */
  getCachedTasks(): TTSTaskInfo[] {
    return Array.from(this.taskCache.values()).sort((a, b) => {
      // 首先按ID降序（ID越大越新）
      if (a.id !== b.id) {
        return b.id - a.id
      }
      // 如果ID相同，按创建时间降序
      const dateA = new Date(a.createdTime).getTime()
      const dateB = new Date(b.createdTime).getTime()
      return dateB - dateA
    })
  }

  /**
   * 删除任务
   */
  async deleteTask(taskId: number): Promise<void> {
    // 从缓存中删除
    this.taskCache.delete(taskId)
    
    // 从数据库中删除
    await ttsStorage.deleteTTSTask(taskId)
    
    // 触发列表更新事件（排序后）
    this.emit('taskListUpdate', this.getCachedTasks())
  }

  /**
   * 清空所有任务
   */
  async clearAllTasks(): Promise<void> {
    // 清空缓存
    this.taskCache.clear()
    
    // 清空数据库
    await ttsStorage.clearTTSHistory()
    
    // 触发列表更新事件
    this.emit('taskListUpdate', [])
  }
}

// 导出单例实例
export const ttsSyncService = TTSSyncService.getInstance()

// 页面加载时自动开始同步
if (typeof window !== 'undefined') {
  // 确保在浏览器环境中执行
  document.addEventListener('DOMContentLoaded', () => {
    ttsSyncService.startSync()
  })

  // 页面关闭时停止同步
  window.addEventListener('beforeunload', () => {
    ttsSyncService.stopSync()
  })

  // 页面隐藏时停止同步，显示时重新开始
  document.addEventListener('visibilitychange', () => {
    if (document.hidden) {
      ttsSyncService.stopSync()
    } else {
      ttsSyncService.startSync()
    }
  })
}